home *** CD-ROM | disk | FTP | other *** search
/ Aminet 44 / Aminet 44 (2001)(GTI - Schatztruhe)[!][Aug 2001].iso / Aminet / comm / misc / Sashi89.lha / Sashi89 / sources / protocol.c < prev    next >
C/C++ Source or Header  |  2001-05-08  |  22KB  |  1,060 lines
  1. /* ANSI */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <ctype.h>
  5. #include <string.h>
  6.  
  7.  
  8. /* Amiga */
  9. #include <exec/types.h>
  10.  
  11. #include "protocol.h"
  12. #include "hard.h"
  13. #include "packet.h"
  14.  
  15. #include "list.h"
  16. #include "config.h"
  17.  
  18.  
  19.  
  20. /*#define TI89_MAXTYPES 48
  21. const char *TI89_TYPES[TI89_MAXTYPES]=
  22. {
  23. "EXPR", "UNKNOWN", "UNKNOWN", "UNKNOWN", "LIST", "UNKNOWN", "MAT", "UNKNOWN",
  24. "UNKNOW", "UNKNOWN", "DATA", "TEXT", "STR", "GDB", "FIG", "UNKNOWN",
  25. "PIC", "UNKNOWN", "PRGM", "FUNC", "MAC", "UNKNOWN", "UNKNOWN", "UNKNOWN",
  26. "UNKNOWN", "UNKNOWN", "UNKNOWN", "UNKNOWN", "UNKNOWN", "BACKUP", "UNKNOWN", "DIR",
  27. "ASM", "UNKNOWN", "IDLIST", "UNKNOWN", "FLASH", "UNKNOWN", "LOCKED", "ARCHIVED",
  28. "UNKNOWN", "UNKNOWN", "UNKNOWN", "UNKNOWN", "UNKNOWN", "UNKNOWN", "UNKNOWN", "UNKNOWN"
  29. };
  30. */
  31.  
  32.  
  33. struct List_Content
  34. {
  35.   ULONG file_offset;
  36.   char name[MAX_NAMELENGTH+1];
  37.   char foldername[MAX_NAMELENGTH+1];
  38.   char type;
  39. };
  40.  
  41.  
  42.  
  43. char filetypes[] = "e---l-m---ctsda-i-pfx---h----b-g-z---------------r";
  44.  
  45.  
  46. int ti_analysedir(Packet *packet, ti_variable *vars, char filter);
  47.  
  48. int ti_sendvardata(FILE *fptr, char *folder, char *name, char type);
  49. void ti_writefileheader(FILE *fptr, char *defaultfolder, char *comment, int nb_vars);
  50. void ti_writevarheader(FILE *fptr, char *name, int type, long int offset);
  51. int ti_downloadvar(char *complete_varpath, Packet *data_packet, ti_variable *var);
  52.  
  53.  
  54. /// int ti_ping(int nb)
  55. int ti_ping(int nb)
  56. {
  57.   UBYTE hello[]={0x08,0x68,0x00,0x00};
  58.   Packet packet;
  59.   int cpt;
  60.  
  61.   ti_initpacket(&packet);
  62.  
  63.   for ( cpt=1; cpt<=nb;cpt++ )
  64.   {
  65. #ifdef DEBUG
  66.         printf(HERE"ping %d\n",cpt);
  67. #endif
  68.         if ( ti_sendbytes(hello,sizeof(hello)) == 0 )
  69.       if ( ti_getpacket(&packet) == 0 )
  70.         return(TI_OK);
  71.  
  72.   }
  73.  
  74.   ti_freepacket(&packet);
  75.   return(TI_TIMEOUT);
  76. }
  77. ///
  78.  
  79. /// int ti_analysedir(Packet *packet, ti_variable *vars, char filter)
  80. int ti_analysedir(Packet *packet, ti_variable *vars, char filter)
  81. /*
  82. if filter == 'v', remove any non-variable entry
  83. if filter == 'f', remove any non-folder entry
  84. */
  85. {
  86.   int cpt, nbvar=0;
  87.   unsigned int index=0;
  88.  
  89.   if ( packet->command != COMMAND_DATA )
  90.     return(TI_PROTOCOL);
  91.  
  92.   for ( cpt=0; cpt<4; cpt++ )
  93.   {
  94.     if ( packet->bytes[index++] != 0 )
  95.       return(TI_PROTOCOL);
  96.   }
  97.  
  98.   while ( index < packet->nb )
  99.   {
  100.  
  101.     for ( cpt=0; cpt<MAX_NAMELENGTH; cpt++ )
  102.       vars[nbvar].name[cpt] = packet->bytes[index++];
  103.  
  104.     vars[nbvar].name[MAX_NAMELENGTH] = 0;
  105.  
  106. #ifdef DEBUG
  107.         printf(HERE"Var %d\n",nbvar);
  108.         printf(HERE" * Name : %s\n",vars[nbvar].name);
  109. #endif
  110.  
  111.     vars[nbvar].type = packet->bytes[index++];
  112. #ifdef DEBUG
  113.         printf(HERE" * Type : %d \n",vars[nbvar].type);
  114. #endif
  115.         vars[nbvar].state= packet->bytes[index++];
  116.     vars[nbvar].size = 0;
  117.  
  118.     for ( cpt=0; cpt<3; cpt++ )
  119.     { /* Get size on 3 bytes */
  120.       vars[nbvar].size += ( (packet->bytes[index++] ) << (8*cpt) );
  121.     }
  122.         index++; /* Skip one byte, unknown use */
  123.  
  124.  
  125.         switch ( filter )
  126.         {
  127.             case 'v':
  128.             case 'V':
  129.                 if ( ti_isvariable(vars[nbvar].type ) )
  130.               nbvar++;
  131.                 break;
  132.             case 'f':
  133.             case 'F':
  134.                 if ( vars[nbvar].type == TI_TYPE_FOLDER )
  135.               nbvar++;
  136.                 break;
  137.             default:
  138.                 nbvar++;
  139.         }
  140.   }
  141.  
  142.   return(nbvar);
  143. }
  144. ///
  145.  
  146. /// int ti_listdir(char *foldname, ti_variable *vars)
  147. int ti_listdir(char *foldname, ti_variable *vars)
  148. {
  149.   UBYTE ldir_sfx[]={0x00,0x00,0x00,0x1B,0x1A};
  150.   Packet packet;
  151.   UBYTE *ldir;
  152.   UBYTE ok[]={0x08,0x56,0x00,0x00};
  153.   UBYTE waiting[]={0x08,0x09,0x00,0x00};
  154.  
  155.   unsigned int cpt;
  156.   int nb;
  157.  
  158.   /*printf(HERE"listing %s\n",foldname);*/
  159.  
  160.   ldir = calloc(sizeof(ldir_sfx)+strlen(foldname)+1,sizeof(UBYTE));
  161.  
  162.   for ( cpt=0; cpt<sizeof(ldir_sfx); cpt++)
  163.     ldir[cpt] = ldir_sfx[cpt];
  164.  
  165.  
  166.   ldir[sizeof(ldir_sfx)] = strlen(foldname);
  167.  
  168.   for ( cpt=0; cpt<strlen(foldname); cpt++)
  169.     ldir[sizeof(ldir_sfx)+cpt+1]=foldname[cpt];
  170.  
  171.  
  172.   ti_initpacket(&packet);
  173.   packet.command = 0xA2;
  174.   ti_cp2packet(&packet,sizeof(ldir_sfx)+strlen(foldname)+1,ldir);
  175.  
  176.  
  177.   if ( ti_sendpacket(&packet) )
  178.   {
  179.     ti_freepacket(&packet);
  180.     return(TI_TIMEOUT);
  181.   }
  182.  
  183.  
  184.   if (
  185.     ti_getpacket(&packet) ||
  186.     ti_getpacket(&packet) ||
  187.     ti_sendbytes(ok,sizeof(ok)) ||
  188.     ti_sendbytes(waiting,sizeof(waiting)) ||
  189.     ti_getpacket(&packet) ||
  190.     ti_getpacket(&packet) )
  191.   {
  192.       ti_freepacket(&packet);
  193.       return(TI_TIMEOUT);
  194.   }
  195.  
  196.  
  197.     nb = ti_analysedir(&packet,vars,'v');
  198.  
  199.   ti_sendbytes(ok,sizeof(ok));
  200.   ti_getpacket(&packet);
  201.   ti_sendbytes(ok,sizeof(ok));
  202.  
  203.   free(ldir);
  204.  
  205.   ti_freepacket(&packet);
  206.   return(nb);
  207. }
  208. ///
  209.  
  210. /// int ti_folderlist(ti_variable *vars)
  211. int ti_folderlist(ti_variable *vars)
  212. {
  213.   Packet packet;
  214.   UBYTE dir[]={0x00,0x00,0x00,0x1F,0x1A,0x00};
  215.   UBYTE ok[]={0x08,0x56,0x00,0x00};
  216.   UBYTE waiting[]={0x08,0x09,0x00,0x00};
  217.   int nb;
  218.  
  219.   if ( ti_ping(3) != TI_OK )
  220.     return(TI_PING);
  221.  
  222.   ti_initpacket(&packet);
  223.   packet.command = 0xA2;
  224.   ti_cp2packet(&packet,sizeof(dir),dir);
  225.  
  226.   if (  ti_sendpacket(&packet)||
  227.         ti_getpacket(&packet) || /* Skip OK */
  228.         ti_getpacket(&packet) || /* Skip ??? */
  229.         ti_sendbytes(ok,sizeof(ok)) || /* OK... */
  230.         ti_sendbytes(waiting,sizeof(waiting)) || /* ... waiting for data */
  231.         ti_getpacket(&packet) || /* Skip OK */
  232.         ti_getpacket(&packet) ) /* Get listing */
  233.   {
  234.     ti_freepacket(&packet);
  235.     return(TI_TIMEOUT);
  236.   }
  237.  
  238.     nb = ti_analysedir(&packet,vars,'f'); /* Analyse it */
  239.  
  240.   if (  nb < 0 ||
  241.         ti_sendbytes(ok,sizeof(ok)) || /* OK for data  */
  242.         ti_getpacket(&packet) ||  /* Skip EOT */
  243.         ti_sendbytes(ok,sizeof(ok)) ) /* OK */
  244.   {
  245.     ti_freepacket(&packet);
  246.     if ( nb < 0 )  return(nb);
  247.     return(TI_TIMEOUT);
  248.   }
  249.  
  250.   ti_freepacket(&packet);
  251.  
  252.   return(nb);
  253.  
  254. }
  255. ///
  256.  
  257. /// int ti_sendfile(char *filename, char *userfolder)
  258. int ti_sendfile(char *filename, char *userfolder)
  259. {
  260.   char folder[MAX_NAMELENGTH+1];
  261.   int nb_entries;
  262.  
  263.   FILE *fptr;
  264.  
  265.   if ( ti_ping(3) != TI_OK )
  266.     return(TI_PING);
  267.  
  268.   if ((fptr = fopen (filename, "rb")) == NULL )
  269.     return(TI_FILE);
  270.  
  271. #ifdef DEBUG
  272.     printf(HERE"Sending %s\n",filename);
  273. #endif
  274.  
  275.   {
  276.     char header[9];
  277.     if ( fread(header,1,8,fptr) != 8 ) /* Read header */
  278.       return(TI_BADFORMAT);
  279.   }
  280.  
  281.  
  282.   fgetc(fptr); /* Skip 01 */
  283.   fgetc(fptr); /* Skip 00 */
  284.  
  285.   if ( fread(folder,1,MAX_NAMELENGTH,fptr) != 8 )
  286.   {
  287. #ifdef DEBUG
  288.     printf(HERE"Cannot read foldername ! \n");
  289. #endif
  290.         return(TI_BADFORMAT);
  291.   }
  292.   folder[MAX_NAMELENGTH]=0;
  293.  
  294.  
  295.   {
  296.     char comment[41];
  297.     if ( fread(comment,1,sizeof(comment)-1,fptr) != sizeof(comment)-1 )
  298.       return(TI_BADFORMAT);
  299.   }
  300.  
  301.  
  302.   nb_entries  = fgetc(fptr);
  303.   nb_entries += (fgetc(fptr)<<8);
  304.  
  305.   /*if ( feof(fptr) )
  306.     return(TI_BADFORMAT);*/
  307.  
  308.   if ( userfolder[0] ) /* Override default folder with user defined folder */
  309.     strncpy(folder,userfolder,MAX_NAMELENGTH);
  310.  
  311.  
  312.  
  313.  
  314.   { /* Get variables informations */
  315.     int entry;
  316.     ULONG offset;
  317.     char name[MAX_NAMELENGTH+1];
  318.     char type;
  319.  
  320.  
  321.     for ( entry=1; entry <= nb_entries ; entry++ )
  322.     {
  323.       int temp;
  324.  
  325.       offset = fgetc(fptr);
  326.       offset += fgetc(fptr)<<8;
  327.       offset += fgetc(fptr)<<16;
  328.       offset += fgetc(fptr)<<24;
  329.  
  330.       if ( (temp=fread(name,1,MAX_NAMELENGTH,fptr)) != MAX_NAMELENGTH )
  331.       {
  332. #ifdef DEBUG
  333.                 printf(HERE"Unable to read name (%d/%d) %d\n",temp,MAX_NAMELENGTH,feof(fptr));
  334. #endif
  335.                 return(TI_BADFORMAT);
  336.       }
  337.  
  338.       name[MAX_NAMELENGTH] = 0;
  339.  
  340.       type = fgetc(fptr);
  341.             //printf(HERE"name(%d) : >%s<\n",entry,name);
  342.       //printf(HERE"offset   : %x\n",offset);
  343.       //printf(HERE"type     : %x\n",type);
  344.       fgetc(fptr);
  345.  
  346.       fgetc(fptr); /* Skip 0's */
  347.       fgetc(fptr);
  348.  
  349.       if ( type != 0x1F )
  350.       {
  351.         long backup_offset = ftell(fptr);
  352.                 //printf(HERE" Jumping to %x\n",(unsigned int)offset);
  353.         if ( fseek(fptr,offset, SEEK_SET) )
  354.           return(TI_BADFORMAT);
  355.  
  356.         {
  357.           int ret;
  358.                     //printf("sending %s\n",name);
  359.           if ( (ret=ti_sendvardata(fptr,folder,name, type)) )
  360.                     {
  361.                         fclose(fptr);
  362.             return(ret);
  363.                     }
  364.         }
  365.  
  366.         //printf(HERE"back to %x\n",backup_offset);
  367.         if ( fseek(fptr,backup_offset, SEEK_SET) )
  368.           return(TI_BADFORMAT);
  369.       }
  370.       else /* folder info */
  371.       if ( userfolder[0] == '\0' )
  372.       {
  373.         //printf(HERE"information supp : folder = <%s>\n",name);
  374.         strncpy(folder,name,MAX_NAMELENGTH);
  375.         folder[MAX_NAMELENGTH] = 0;
  376.       }
  377.  
  378.  
  379.     }
  380.   }
  381.  
  382.   /*system("date");*/
  383.   fclose(fptr);
  384.  
  385.   return(TI_OK);
  386. }
  387. ///
  388.  
  389. /// int ti_sendvardata(FILE *fptr, char *folder, char *name, char type)
  390. int ti_sendvardata(FILE *fptr, char *folder, char *name, char type)
  391. {
  392.  
  393.   unsigned short int size;
  394.   UBYTE *buffer;
  395.   UBYTE ok[]={0x08,0x56,0x00,0x00};
  396.   UBYTE eot[]={0x08,0x92,0x00,0x00};
  397.   char fullname[200];
  398.   UBYTE dummy;
  399.  
  400.   if ( fgetc(fptr)||fgetc(fptr)||fgetc(fptr)||fgetc(fptr) )
  401.   {
  402.     /*printf(HERE"pas à 0 ! \n");
  403.     return(1);*/
  404.   }
  405.  
  406.   size = (fgetc(fptr)<<8) + fgetc(fptr);
  407.  
  408.   if ( feof(fptr) || size == 0 )
  409.   {
  410. #ifdef DEBUG
  411.         printf(HERE"Error : EOF size=%d\n",size);
  412. #endif
  413.     return(TI_BADFORMAT);
  414.   }
  415.  
  416.  
  417.   buffer = calloc (size,sizeof(UBYTE));
  418.  
  419.   if ( fread (buffer,sizeof(UBYTE),size,fptr) != size )
  420.   {
  421. #ifdef DEBUG
  422.     printf(HERE"Could not read %d(%x) bytes in file.\n",size,size);
  423. #endif
  424.         free(buffer);
  425.     return(TI_BADFORMAT);
  426.   }
  427.  
  428.     sprintf(fullname,"%s\\%s",folder,name);
  429.  
  430.  
  431.  
  432.   {
  433.     UBYTE *varhead;
  434.     int index=0;
  435.     unsigned int cpt;
  436.     Packet packet;
  437.  
  438.  
  439.     if ( ! ( varhead = calloc(7+strlen(fullname),sizeof(UBYTE)) ) )
  440.       return(TI_MEMORY);
  441.  
  442.     varhead[index++] = (size+2) & 0xFF;
  443.     varhead[index++] = (size+2) >> 8;
  444.     varhead[index++] = 0;
  445.     varhead[index++] = 0;
  446.  
  447.     varhead[index++] = type;
  448.     varhead[index++] = strlen(fullname);
  449.  
  450.     for ( cpt=0; cpt<strlen(fullname); cpt++ )
  451.       varhead[index++] = fullname[cpt];
  452.  
  453.     varhead[index++] = 0;
  454.  
  455.     ti_initpacket(&packet);
  456.     packet.command = 0x06;
  457.     ti_cp2packet(&packet,index,varhead);
  458.  
  459.     if ( ti_sendpacket(&packet) )
  460.     {
  461.       ti_freepacket(&packet);
  462.       return(TI_TIMEOUT);
  463.     }
  464.  
  465.     if ( ti_getpacket(&packet) ||   /* Skip OK */
  466.          ti_getpacket(&packet) || /* Skip Wait */
  467.          ti_sendbytes(ok,sizeof(ok)) )
  468.     {
  469.       ti_freepacket(&packet);
  470.       return(TI_TIMEOUT);
  471.     }
  472.  
  473.     ti_freepacket(&packet);
  474.     free(varhead);
  475.   }
  476.  
  477.   {
  478.     UBYTE *data;
  479.     int cpt,index=0;
  480.     Packet packet;
  481.  
  482.     if ( ! ( data = calloc(6+size,sizeof(UBYTE)) ) )
  483.       return(TI_MEMORY);
  484.  
  485.     for ( cpt=0; cpt<4; cpt++ )
  486.       data[index++] = 0;
  487.  
  488.     data[index++] = size>>8;
  489.     data[index++] = size&0xFF;
  490.  
  491.     for ( cpt=0; cpt<size; cpt++ )
  492.       data[index++] = buffer[cpt];
  493.  
  494.     ti_initpacket(&packet);
  495.     packet.command = 0x15;
  496.     ti_cp2packet(&packet,6+size,data);
  497.  
  498.     ti_sendpacket(&packet);
  499.     ti_freepacket(&packet);
  500.  
  501.     {
  502.       if (
  503.         ti_recvbyte(&dummy) ||
  504.         ti_recvbyte(&dummy) ||
  505.         ti_recvbyte(&dummy) ||
  506.         ti_recvbyte(&dummy) ) /* Skip OK */
  507.           return(TI_TIMEOUT);
  508.     }
  509.  
  510.     if ( ti_sendbytes(eot,sizeof(eot)) )
  511.       return(TI_TIMEOUT);
  512.  
  513.     {
  514.       if (
  515.         ti_recvbyte(&dummy) || /* Skip OK */
  516.         ti_recvbyte(&dummy) || /* Skip OK */
  517.         ti_recvbyte(&dummy) || /* Skip OK */
  518.         ti_recvbyte(&dummy) ) /* Skip OK */
  519.           return(TI_TIMEOUT);
  520.         }
  521.  
  522.     free(data);
  523.   }
  524.  
  525.   free(buffer);
  526.  
  527.   return(TI_OK);
  528. }
  529. ///
  530.  
  531. /// void ti_writefileheader(FILE *fptr, char *defaultfolder, char *comment, int nb_vars)
  532. void ti_writefileheader(FILE *fptr, char *defaultfolder, char *comment, int nb_vars)
  533. {
  534.     char header[]={'*','*','T','I','9','2','P','*','\1','\0'};
  535.  
  536.   unsigned int cpt;
  537.  
  538.   for ( cpt=0; cpt<sizeof(header); cpt++) /* Write header */
  539.     fputc(header[cpt],fptr);
  540.  
  541.   { /* Write folder */
  542.     int flag=0;
  543.     for ( cpt=0; cpt<8; cpt++ ) /* TODO : remove explicit constants */
  544.     {
  545.       if ( ! flag )
  546.         if ( defaultfolder[cpt] == '\0' )
  547.           flag = 1;
  548.  
  549.       if ( flag )
  550.         fputc('\0' ,fptr);
  551.       else
  552.         fputc(defaultfolder[cpt],fptr);
  553.     }
  554.   }
  555.  
  556.   { /* Write comment */
  557.     int flag=0;
  558.     for ( cpt=0; cpt<40; cpt++ ) /* TODO : remove explicit constants */
  559.     {
  560.       if ( ! flag )
  561.         if ( comment[cpt] == '\0' )
  562.           flag = 1;
  563.  
  564.       if ( flag )
  565.         fputc(' ',fptr);
  566.       else
  567.         fputc(comment[cpt],fptr);
  568.     }
  569.   }
  570.  
  571.   fputc(nb_vars & 0xFF, fptr); /* write nb of vars */
  572.   fputc((nb_vars >> 8)&0xFF, fptr);
  573. }
  574. ///
  575.  
  576. /// void ti_writevarheader(FILE *fptr, char *name, int type, long int offset)
  577. void ti_writevarheader(FILE *fptr, char *name, int type, long int offset)
  578. {
  579.  
  580.   fputc(offset&0xFF,fptr);
  581.   fputc((offset>>8)&0xFF,fptr);
  582.   fputc((offset>>16)&0xFF,fptr);
  583.   fputc((offset>>24)&0xFF,fptr);
  584.  
  585.  
  586.   { /* Write name */
  587.     int flag=0;
  588.     int  cpt;
  589.  
  590.     for ( cpt=0; cpt<8; cpt++ ) /* TODO : remove explicit constants */
  591.     {
  592.       if ( ! flag )
  593.         if ( name[cpt] == '\0' )
  594.           flag = 1;
  595.  
  596.       if ( flag )
  597.         fputc('\0' ,fptr);
  598.       else
  599.         fputc(name[cpt],fptr);
  600.     }
  601.   }
  602.  
  603.   fputc(type&0xFF,fptr);
  604.   fputc((type>>8)&0xFF,fptr);
  605.  
  606.   fputc(0,fptr);
  607.   fputc(0,fptr);
  608. }
  609. ///
  610.  
  611. /// int ti_getvar(char *foldername, char *varname, char *filename)
  612. int ti_getvar(char *foldername, char *varname, char *filename)
  613. {
  614.   Packet packet;
  615.   //UBYTE ok[]={0x08,0x56,0x00,0x00};
  616.   FILE *fptr;
  617.   unsigned int cpt;
  618.  
  619.   char complete_varpath[17];
  620.  
  621.   if ( ti_ping(3) != TI_OK )
  622.     return(TI_PING);
  623.  
  624.   if ( foldername[0] == '\0' ) // no folder specified
  625.     foldername = "main";
  626.  
  627.  
  628.   if ((fptr = fopen (filename, "wb")) == NULL )
  629.   {
  630. #ifdef DEBUG
  631.     printf(HERE"error opening %s\n",filename);
  632. #endif
  633.         return(TI_FILE);
  634.   }
  635.  
  636.   if ( foldername[0] )
  637.         sprintf(complete_varpath,"%s\\%s",foldername,varname);
  638.  
  639.   //printf(HERE"getting %s\n",complete_varpath);
  640.  
  641.  
  642.  
  643.   ti_initpacket(&packet);
  644.   {
  645.     int ret;
  646.     if ( (ret=ti_downloadvar(complete_varpath, &packet, NULL) ) )
  647.     {
  648.       ti_freepacket(&packet);
  649.             fclose(fptr);
  650.       return(ret);
  651.     }
  652.   }
  653.  
  654.   ti_writefileheader(fptr,"main","",1);
  655.   ti_writevarheader(fptr,varname,0x12,0x52);
  656.  
  657.  
  658.   /*sprintf(HEREfilename,"%s.89%c",varname,filetypes[*//**/
  659.  
  660.   {
  661.     int index;
  662.     for ( index = 0; index < 4 ; index ++ )
  663.     {
  664.       fputc(((0x52+2+packet.nb)>>(index*8))&0xFF,fptr);;
  665.       /*printf(HERE"%x ",head.length[index]);*/
  666.     }
  667.   }
  668.  
  669.   fputc(0xA5,fptr);
  670.   fputc(0x5A,fptr);
  671.   fputc(0x00,fptr);
  672.   fputc(0x00,fptr);
  673.   fputc(0x00,fptr);
  674.   fputc(0x00,fptr);
  675.  
  676.  
  677.   fputc((packet.nb-6)>>8,fptr);
  678.   fputc((packet.nb-6)&0xFF,fptr);
  679.  
  680.  
  681.  
  682.   for ( cpt = 6; cpt < packet.nb ; cpt ++ )
  683.     fputc(packet.bytes[cpt],fptr);
  684.  
  685.   fputc(0x00,fptr); /* should be checksum */
  686.   fputc(0x00,fptr);
  687.  
  688.   fclose(fptr);
  689.  
  690.   ti_freepacket(&packet);
  691.  
  692.   return(TI_OK);
  693. }
  694. ///
  695.  
  696. /// int ti_getfolder(char *foldername, char *filename)
  697. int ti_getfolder(char *foldername, char *filename)
  698. /*
  699. Download one or all folders
  700. */
  701. {
  702.   //UBYTE ok[]={0x08,0x56,0x00,0x00};
  703.   FILE *fptr;
  704.     int var, nb_vars, folder,nb_folders;
  705.  
  706.   unsigned long int buffer_index=0,buffer_size=0;
  707.   char *buffer;
  708.  
  709.     ti_variable folders[MAX_NBNAME];
  710.     ti_variable vars[MAX_NBNAME];
  711.  
  712.     Packet packet;
  713.     unsigned long int file_offset;
  714.  
  715.  
  716.   char complete_varpath[17];
  717.  
  718.   if ( ti_ping(3) != TI_OK )
  719.     return(TI_PING);
  720.  
  721.     /* Init. the "folders" array */
  722.     if ( foldername == NULL||foldername[0] == '\0' ) // no folder specified
  723.     {
  724.         nb_folders =ti_folderlist(folders);
  725.     }
  726.     else
  727.     {
  728.         nb_folders = 1;
  729.         strcpy(folders[0].name,foldername);
  730.         //printf(HERE"  Getting folder %s\n",foldername);
  731.     }
  732.  
  733.  
  734.  
  735.   if ((fptr = fopen (filename, "wb")) == NULL )
  736.   {
  737. #ifdef DEBUG
  738.     printf(HERE"error opening %s\n",filename);
  739. #endif
  740.         return(TI_FILE);
  741.   }
  742.  
  743.  
  744.  
  745.     buffer_size = 0;
  746.     buffer  = NULL;
  747.  
  748.     nb_vars = 0;
  749.  
  750.     for ( folder = 0; folder<nb_folders; folder++ )
  751.     {
  752.         int nb_vars_this;
  753.  
  754.  
  755.         //printf(HERE" Folder %s\n",folders[folder].name);
  756.  
  757.         
  758.         if ( (nb_vars_this = ti_listdir(folders[folder].name, vars)) < 0 )
  759.       {
  760.         fclose(fptr);
  761.         return(TI_PROTOCOL);
  762.         }
  763.         //printf(HERE" nb vars of %s : %d\n",folders[folder].name,nb_vars_this);
  764.         
  765.         /* Get the nb of vars required by this folder :
  766.              one for the folder, nb_vars_this for its variables */
  767.  
  768.         
  769.     for ( var=0 ; var<nb_vars_this ; var ++)
  770.         buffer_size += (vars[var].size+8);
  771.         
  772.         nb_vars += ( 1 + nb_vars_this );
  773.     /* In the data part of the file, we found, for each var :
  774.         4     :  zeros
  775.         2     :  length
  776.         length:  variable data
  777.         2     :  checksum
  778.     */
  779.     }
  780.  
  781.     //printf(HERE" buffer size : %ld\n",buffer_size);
  782.     if ( (buffer = malloc(buffer_size)) == NULL )
  783.     {
  784.         fclose(fptr);
  785.         return(TI_MEMORY );
  786.     }
  787.  
  788.     ti_writefileheader(fptr,"","",nb_vars);
  789.  
  790.     ti_initpacket(&packet);
  791.  
  792.     file_offset=ftell(fptr)+2+16*nb_vars;
  793.  
  794.  
  795.     for ( folder = 0; folder<nb_folders; folder ++)
  796.     {
  797.         int nb_vars_this;
  798.  
  799.         if ( ti_ping(3) == TI_TIMEOUT )
  800.             return(TI_TIMEOUT);
  801.  
  802.         nb_vars_this = ti_listdir(folders[folder].name, vars);
  803.         
  804.         //printf(HERE" Downloading %s : %d vars\n",folders[folder].name,nb_vars_this);
  805.  
  806.         /* Write folder info */
  807.         ti_writevarheader(fptr,folders[folder].name,TI_TYPE_FOLDER,file_offset);
  808.  
  809.         for ( var=0 ; var<nb_vars_this ; var ++)
  810.     {
  811.       int ret;
  812.       unsigned long int cpt;
  813.  
  814.             sprintf(complete_varpath,"%s\\%s",folders[folder].name,vars[var].name);
  815.  
  816.             //printf(HERE"getting %s  type=%d...\n",complete_varpath,vars[var].type);
  817.  
  818.             if ( ! ti_isvariable(vars[var].type ) )
  819.                 continue; /* Not a variable, skip it */
  820.  
  821.       ti_writevarheader(fptr,vars[var].name,vars[var].type,file_offset);
  822.       file_offset += (vars[var].size+6);
  823.  
  824.  
  825.       if ( ti_ping(3) != TI_OK )
  826.       {
  827.         ti_freepacket(&packet);
  828.         fclose(fptr);
  829.         free(buffer);
  830.         return(TI_PING);
  831.       }
  832.  
  833.       if ( (ret=ti_downloadvar(complete_varpath, &packet,&(vars[var]) ) ) )
  834.       {
  835. #ifdef DEBUG
  836.         printf(HERE"Error downloading var (%d)\n",ret);
  837. #endif
  838.                 ti_freepacket(&packet);
  839.         fclose(fptr);
  840.         free(buffer);
  841.         return(ret);
  842.       }
  843.       /* Copy data to buffer */
  844.       for ( cpt = 1; cpt <= 4 ; cpt ++ ) /* Four 0 */
  845.         buffer[buffer_index++] = 0;
  846.  
  847.       /* Length : */
  848.       vars[var].size -= 2;
  849.       buffer[buffer_index++] = (vars[var].size>>8)&0xFF;
  850.       buffer[buffer_index++] = vars[var].size&0xFF;
  851.  
  852.             //printf(HERE"taille : %x\n",vars[var].size);
  853.  
  854.       {
  855.         unsigned long int checksum=0;
  856.         /* Data : */
  857.         for ( cpt = 6; cpt < packet.nb ; cpt ++ )
  858.         {
  859.           buffer[buffer_index++] = packet.bytes[cpt];
  860.           checksum += packet.bytes[cpt];
  861.         }
  862.         /* Checksum : */
  863.         buffer[buffer_index++] = checksum&&0xFF;
  864.         buffer[buffer_index++] = (checksum>>8)&&0xFF;
  865.       }
  866.  
  867.       //printf(HERE"Copying data to buffer... ok !\n");
  868.     }
  869.   }
  870.  
  871.     ti_freepacket(&packet);
  872.  
  873.   fputc(0xA5,fptr);
  874.   fputc(0x5A,fptr);
  875.  
  876.  
  877.   {
  878.     int cpt;
  879.     for ( cpt = 0; cpt < buffer_index ; cpt ++ )
  880.       fputc(buffer[cpt],fptr);
  881.   }
  882.  
  883.   fputc(0x00,fptr); // should be checksum
  884.   fputc(0x00,fptr);
  885.  
  886.   fclose(fptr);
  887.  
  888.   return(TI_OK);
  889. }
  890. ///
  891.  
  892. /// int ti_downloadvar(char *complete_varpath, Packet *data_packet, ti_variable *var)
  893. int ti_downloadvar(char *complete_varpath, Packet *data_packet, ti_variable *var)
  894. {
  895.   int index;
  896.   Packet packet; /* temp. packet */
  897.   UBYTE ok[]={0x08,0x56,0x00,0x00};
  898.   unsigned int cpt;
  899.  
  900.   /* !!! */
  901.   ti_variable temp;
  902.  
  903.   if ( ! var )
  904.     var = &temp; /**/
  905.  
  906.   ti_initpacket(&packet);
  907.   ti_allocpacket(&packet,6+strlen(complete_varpath));
  908.  
  909.   index =0;
  910.   packet.command= 0xA2;
  911.  
  912.   packet.bytes[index++] = 0;
  913.   packet.bytes[index++] = 0;
  914.   packet.bytes[index++] = 0;
  915.   packet.bytes[index++] = 0;
  916.  
  917.   packet.bytes[index++] = 0;
  918.   packet.bytes[index++] = strlen(complete_varpath);
  919.  
  920.   for ( cpt=0; cpt<strlen(complete_varpath); cpt++ )
  921.     packet.bytes[index++] = complete_varpath[cpt];
  922.  
  923.   packet.nb     = index;
  924.  
  925.   if (     ti_sendpacket(&packet)
  926.         || ti_getpacket(&packet) /*ok */
  927.         ||  packet.bytes[1] != 0x00 )
  928.   {
  929. #ifdef DEBUG
  930.     printf(HERE"No such var\n");
  931. #endif
  932.         ti_freepacket(&packet);
  933.     return(TI_NOTEXIST);
  934.   }
  935.  
  936.  
  937.   if (      ti_getpacket(&packet)        /* Local name */
  938.         ||  ti_sendbytes(ok,sizeof(ok))) /* OK */
  939.   {
  940.     ti_freepacket(&packet);
  941.     return(TI_PROTOCOL);
  942.   }
  943.  
  944.   if ( var != NULL )
  945.   { /* update var info */
  946.     int cpt;
  947.     int index=0;
  948.  
  949.         /*for ( cpt=0; cpt<packet.nb; cpt++)
  950.             printf(HERE"%x ",packet.bytes[cpt]);
  951.         printf(HERE"\n");*/
  952.  
  953.     var->size = 0;
  954.     for ( cpt=0; cpt<4; cpt++)
  955.       var->size += ( packet.bytes[index++] << (cpt*8));
  956.     //var->size -= 2;
  957.  
  958.     var->type += packet.bytes[index++];
  959.  
  960.     for ( cpt=0; cpt<MAX_NAMELENGTH; cpt++)
  961.       var->name[cpt] = packet.bytes[index++];
  962.         
  963.         //printf(HERE"info maj : %s %x %x\n",var->name,var->size,var->type);
  964.   }
  965.  
  966.   packet.command= COMMAND_WAITING;
  967.   packet.nb     = 0xFFFF;
  968.     
  969.     if (      ti_sendpacket(&packet) /* waiting */ )
  970.     {
  971. #ifdef DEBUG
  972.         printf(HERE"Error 1 getting variable data\n");
  973. #endif
  974.         ti_freepacket(&packet);
  975.         return(TI_PROTOCOL);
  976.     }
  977.  
  978.     if (      ti_getpacket(&packet) /* OK */ )
  979.     {
  980. #ifdef DEBUG
  981.         printf(HERE"Error 2 getting variable data\n");
  982. #endif
  983.         ti_freepacket(&packet);
  984.         return(TI_PROTOCOL);
  985.     }
  986.  
  987.     if ( ti_getpacket(data_packet) /* Data */ )
  988.   {
  989. #ifdef DEBUG
  990.         printf(HERE"Error getting variable data\n");
  991. #endif
  992.         ti_freepacket(&packet);
  993.     return(TI_PROTOCOL);
  994.   }
  995.  
  996.   ti_sendbytes(ok,sizeof(ok));
  997.  
  998.   ti_getpacket(&packet); /* EOT */
  999.  
  1000.   ti_freepacket(&packet);
  1001.   return(TI_OK);
  1002. }
  1003. ///
  1004.  
  1005.  
  1006. int ti_isvariable(ti_type type)
  1007. {
  1008.     switch (type)
  1009.     {
  1010.         case TI_TYPE_EXPR    :
  1011.         case TI_TYPE_LIST       :
  1012.         case TI_TYPE_MATRIX  :
  1013.         case TI_TYPE_DATA    :
  1014.         case TI_TYPE_TEXT         :
  1015.         case TI_TYPE_STRING     :
  1016.         case TI_TYPE_GDB         :
  1017.         case TI_TYPE_FIGURE     :
  1018.         case TI_TYPE_PICTURE :
  1019.         case TI_TYPE_PRGM         :
  1020.         case TI_TYPE_FUNC    :
  1021.         case TI_TYPE_MAC     :
  1022.         case TI_TYPE_ASM         :
  1023.                 return(1);
  1024.         case TI_TYPE_FOLDER          :
  1025.         default:
  1026.             return(0);
  1027.     }
  1028. }
  1029. char *ti_code2string(int code)
  1030. {
  1031.   switch ( code )
  1032.   {
  1033.     case TI_OK:
  1034.       return("No error");
  1035.       break;
  1036.     case TI_PROTOCOL:
  1037.             return("Protocol error.\nPlease report to "CONFIG_EMAIL);
  1038.       break;
  1039.     case TI_PING:
  1040.       return("The TI did not respond to a ping.\nCheck cable and TI.");
  1041.       break;
  1042.     case TI_FILE:
  1043.       return("File access error.\nPlease check existence and/or rights.");
  1044.       break;
  1045.     case TI_BADFORMAT:
  1046.       return("Error : bad file format.");
  1047.       break;
  1048.     case TI_MEMORY:
  1049.       return("Error : could not allocate memory.");
  1050.       break;
  1051.     case TI_NOTEXIST:
  1052.       return("Error : no such variable.");
  1053.       break;
  1054.     default:
  1055.       return("Timeout.\nThere has been a problem with the transfer.");
  1056.       break;
  1057.   }
  1058. }
  1059.  
  1060.